bondscell_results$334abd5f-8a2c-4e05-96cc-feb9dd8f30aequeued¤logsrunning¦outputbodyF1: Function Syntax (Multi-line & Defaults)
Basic Multi-line: Define a function calculate_vol(l, w, h) using the function ... end block. It should return the product of the three arguments.
Adding Defaults: Redefine the function so h has a default value of 4.
Testing Defaults: Call calculate_vol(5, 5).
Note: You only provided 2 arguments, so Julia automatically supplies 4 for h, yielding 100 for the result; what will calculate_vol(5, 5, 5) produce?
1-4: Functions
Last Updated: 2 May 2026
Functions in Julia
Introduction to the contruction of Julia functions and their implementation by Julia.
If you come from Python or Java, functions are attached to classes. In Julia, functions are standalone citizens, and they define the behavior of the language. We will cover the syntax, the argument system, and introduce a key Julia feature: multiple dispatch.
6: Function Broadcasting
Create a function to add and multiply three scalars.
Execute the function for three scalar values.
Construct three vectors of equal length.
Execute the function using those three vectors.
What happens?
Execute the same function, but append a . after the name and before the opening parenthesis.
What happens now?
Summary
Three versions of function definitions: multi-line blocks, one-liners, or anonymous (lambdas).
Positional and keyword arguments are separated by a ;.
Positional arguments are required. Keyword arguments are optional.
Multiple Dispatch is used to determine the correct function to execute, making the language composable and highly performant.
2: Keywords & Single-liners
Multiple Dispatch
The most important part and a core reason for Julia's existence.
Single Dispatch
Object-oriented languages such as Python and Java use single dispatch for choosing the function or method to execute. That means that the function is determined using the function name and the type of the first argument. This is called single dispatch. Therefore, the functions or methods are tightly bound to the object or class. When you call obj.method(arg), the language transforms that expression into method(obj, arg).
Single dispatch creates the Expression Problem. For example, a + b calls a.__add__(b) in Python. If the object a is known, but not b, there is no problem; the __add__ function can still be called. However, if a is unknown, what do we do now? In Python this problem is solved by the __radd__ function. Python will try __add__, if that fails, then it will try __radd__. Therefore, when we add an __add__ operator to a new class in Python, the new class must implement the __radd__ method too, because other classes do not know about our new classs.
Multiple Dispatch
Julia is not an object-oriented language. It is functional language. When you call func(arg1, arg2), Julia looks at the types of the function's positional arguments to determine the version of the function to execute. This is called multiple dispatch. Julia will look at the argument types of all positional arguments, i.e., arg1 and arg2, and choose the function that has that exact type signature. Multiple dispatch makes it easier for a new Julia type to extend the functional interface of another type.
The example below illustrates that situation. Two fAdd functions are implemented, one for each situation. Julia then determines which version of that function to execute. The situation is similar to Python's __add__ and __radd__, except that Python first tries to use __add__ and when that fails, tries __radd__. Whereas, Julia just chooses the correct function the first time. The following is an example of how Julia may implement this situation.
julia> # Define additon for an integer and a float, and the other way around:
julia> fAdd(a::Int, b::Float64) = a + b
julia> fAdd(a::Float64, b::Int) = a + b
Why is this powerful?
Symmetry: You don't need radd because compared with (a::Float, b::Int), (a::Int, b::Float) is just a different method.
Extensibility: If you import a library that defines a Planet type, and another library that defines a Satellite type, you can define a collide(p::Planet, s::Satellite) function in your own code without modifying the source code of either library.
Trying to add two integers or two floating points fails, e.g., "ERROR: MethodError: no method matching fAdd(::Float64, ::Float64)." If you know, for example, that a particular function is only supposed to be called with an integer and a float, and you don't want to worry about the order, you now have a check on your code.
Problems
Remember that you can get help either through `?` in a REPL or with "Live Docs" right here in Pluto (lower right-hand corner)
Function Arguments
Positional and Keyword
Functions have two types of arguments, positional and keyword. They are separated using a ';' (semi-colon). Positional arguments are required, whereas keyword arguments are optional. The next section will show the importance of positional arguments.
julia> # a and b are positional, while scale and offset are keywords
julia> function transform(a, b; scale=1.0, offset=0.0)
return (a + b) * scale + offset
end
julia> # Usage
julia> transform(10, 20; scale=2.0)
Default Values and Methods
Positional arguments can have default values, which means the default value will be used if the argument is missing.
julia> # This function defines a default value for the y.
julia> myfunc(x, y=10) = x * y
Julia creates two versions or methods of this function, one with two arguments and one with one argument.
julia> myfunc(x, y)
julia> myfunc(x) # The 2nd positional argument will have the value 10.
5: Specialization & Dispatch
Specific Definition: add a new method to the same function name, my_add, but constrain the types to Strings only.
Check Methods: Run methods(my_add) again. You should now see 2 methods.
Dispatch in Action:
Execute my_add(5, 5). (Julia chooses the generic version).
Execute my_add("A", "B"). (Julia chooses the specific String version).
The Rule: Julia always executes the most specific method that matches the arguments provided.
Defining Functions
Julia offers three syntactic ways to define a function. They all compile down to the same code, so choose the syntax that is most convenient or appropriate.
Default Syntax
The standard multi-line version looks similar to other languages. It uses the function statement and closes with the end statement.
julia> function hypotenuse(a, b)
result = sqrt(a^2 + b^2)
return result
end
Single-Line Syntax
The single-line assignment form may be unique to Julia and is perfect for short operations. While functionally identical to the multiline version, it reduces visual clutter for simple logic.
julia> hypotenuse(a, b) = sqrt(a^2 + b^2)
Note
The compiler will automatically inline functions to improve performance, unlike C or Python. Therefore, there is no performance hit by using functions and their use is encouraged for convenience and readability.
Anonymous Functions (Lambdas)
An anonymous function uses the arrow syntax: ->. The variables before the -> are the arguments to be used and the expression afterward is the function body. They are often used in functional programming contexts such as map, filter or findall to define a filter.
julia> # Equivalent to Python's: lambda x: x^2 + 2x - 1
julia> f = x -> x^2 + 2x - 1
julia> # Usage in a map function
julia> map(x -> x^2, [1, 2, 3])
julia> # Two arrays zipped together returning a Tuple with two values.
julia> map(((x, y),) -> x > 2 && y > 4, zip(1:5, 2:6))
3: Anonymous Functions (Map & Filter)
The Syntax: An anonymous function (lambda) looks like x -> x + 1.
Map: Use map() with an anonymous function to double every number in the list [1, 2, 3, 4].
Filter: Use filter() with an anonymous function to extract numbers greater than 5 from the list [3, 4, 5, 6, 7].
4: The Generic add()
Generic Definition: Define a function my_add(a, b) = a + b. Do not add any ::Type annotations.
Duck Typing:
Try my_add(10, 20) (Integers).
Try my_add(3.14, 2.0) (Floats).
Try my_add("Hello ", "World") (Strings).
Observation: It works for all of them because the underlying + is defined for all these types.
Introspection: Run methods(my_add).
Summary of Dispatch
Python: dog.bark(at_stranger) -> Logic lives in dog.
Julia: bark(dog, stranger) -> Logic lives in the bark function, selected specifically for the combination of Dog and Stranger.